package com.apimanage.api.controller;

import com.apimanage.api.entity.Api;
import com.apimanage.api.entity.ApiVersion;
import com.apimanage.api.service.ApiService;
import com.apimanage.common.entity.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * API控制器
 * 提供API的创建、更新、删除、查询、发布、下线以及版本管理等功能
 * 作为API管理平台的核心功能入口，负责API全生命周期管理
 * 
 * @author API管理平台
 * @version 1.0
 * @since 2023-01-01
 */
@RestController
@RequestMapping("/api")
public class ApiController {

    @Autowired
    private ApiService apiService;

    /**
     * 创建API接口
     * 接收API基本信息，创建新的API实体并保存到数据库
     * 新创建的API初始状态为草稿状态
     * 
     * @param api API实体对象，包含API的基本信息（名称、编码、描述、所属项目等）
     * @return 操作结果，包含创建成功的API信息
     */
    @PostMapping("/create")
    public Result<?> createApi(@RequestBody Api api) {
        Api createdApi = apiService.createApi(api);
        return Result.success("创建成功", createdApi);
    }

    /**
     * 更新API接口
     * @param api API实体对象，包含要更新的API信息
     * @return 操作结果，包含更新后的API信息
     */
    @PutMapping("/update")
    public Result<?> updateApi(@RequestBody Api api) {
        Api updatedApi = apiService.updateApi(api);
        return Result.success("更新成功", updatedApi);
    }

    /**
     * 删除API接口
     * @param id API的唯一标识
     * @return 操作结果
     */
    @DeleteMapping("/delete/{id}")
    public Result<?> deleteApi(@PathVariable Long id) {
        apiService.deleteApi(id);
        return Result.success("删除成功");
    }

    /**
     * 根据ID查询API详情接口
     * @param id API的唯一标识
     * @return 操作结果，包含API的详细信息
     */
    @GetMapping("/get/{id}")
    public Result<?> getApiById(@PathVariable Long id) {
        Api api = apiService.getApiById(id);
        return Result.success("查询成功", api);
    }

    /**
     * 分页查询API列表接口
     * @param params 包含查询条件和分页参数的Map
     * @return 操作结果，包含符合条件的API列表
     */
    @PostMapping("/list")
    public Result<?> getApiPage(@RequestBody Map<String, Object> params) {
        List<Api> apiList = apiService.getApiPage(params);
        return Result.success("查询成功", apiList);
    }

    /**
     * 发布API接口
     * 将API状态设置为已发布，使其可被调用
     * @param id API的唯一标识
     * @return 操作结果
     */
    @PutMapping("/publish/{id}")
    public Result<?> publishApi(@PathVariable Long id) {
        apiService.publishApi(id);
        return Result.success("发布成功");
    }

    /**
     * 下线API接口
     * 将API状态设置为已下线，暂停其调用服务
     * @param id API的唯一标识
     * @return 操作结果
     */
    @PutMapping("/offline/{id}")
    public Result<?> offlineApi(@PathVariable Long id) {
        apiService.offlineApi(id);
        return Result.success("下线成功");
    }

    /**
     * 创建API版本接口
     * 为指定API创建新版本，实现API的版本控制
     * @param apiVersion API版本实体对象
     * @return 操作结果，包含创建成功的API版本信息
     */
    @PostMapping("/version/create")
    public Result<?> createApiVersion(@RequestBody ApiVersion apiVersion) {
        ApiVersion createdVersion = apiService.createApiVersion(apiVersion);
        return Result.success("创建版本成功", createdVersion);
    }

    /**
     * 获取API版本列表接口
     * 查询指定API的所有历史版本信息
     */
    @GetMapping("/version/list/{apiId}")
    public Result<?> getApiVersions(@PathVariable Long apiId) {
        List<ApiVersion> versions = apiService.getApiVersions(apiId);
        return Result.success("查询成功", versions);
    }

    /**
     * 获取API当前版本
     */
    @GetMapping("/version/current/{apiId}")
    public Result<?> getCurrentVersion(@PathVariable Long apiId) {
        ApiVersion version = apiService.getCurrentVersion(apiId);
        return Result.success("查询成功", version);
    }

    /**
     * 设置API当前版本
     */
    @PutMapping("/version/setCurrent/{versionId}")
    public Result<?> setCurrentVersion(@PathVariable Long versionId) {
        apiService.setCurrentVersion(versionId);
        return Result.success("设置成功");
    }
}